Java developer demand and investment in related developer tools are expected to significantly increase in 2024 and beyond.

Graphs are powerful data structures, but they lack first-class support in most programming languages. This is due to the sheer number of design choices involved in representing graphs, as well as the importance of performance in graph algorithms. Graph libraries often try to balance flexibility and performance, but this can be difficult as different algorithms work best with different representations. As a result, using graphs often requires developers to make difficult trade-offs or implement custom solutions.

TypeScript 5.4 features better type inference, support for new JavaScript methods like Object.groupBy, and stricter type-checking to catch potential errors.

An online book for learning JavaScript.

Figma recently migrated its custom Skew programming language to TypeScript, a move made possible by improved browser support for WebAssembly and internal optimizations. This transition allows for seamless integration with Figma's existing codebase and external libraries, easier onboarding for new developers, and access to the TypeScript developer ecosystem. In this article, the Figma engineering team goes over their migration process, which was done gradually and automatically so as to not disrupt developer workflows internally.

C++17, C++20, and C++23 have introduced improvements to enum classes, enhancing their type safety and usability through features like direct initialization from underlying types, the 'using enum' keyword, and the std::to_underlying utility.

This proposal introduces the ?= operator, which makes error handling easier by transforming function results into a [error, result] tuple. It also supports recursive handling of promises and objects implementing Symbol.result, making error checking streamlined across various JavaScript APIs.

Python continues to lead IEEE Spectrum's 2024 programming language rankings, driven by its dominance in AI and education, while SQL remains highly sought after by employers. Rising stars include TypeScript and Rust, with the latter gaining attention for its memory safety features.

The author reflects on their experience with the Rust programming language, likening it to the first generation of the iPhone—innovative but incomplete. Initially captivated by Rust's features such as memory safety and a modern package manager, the author expresses frustration after four years of use, feeling that the language has stagnated. They note a significant slowdown in the introduction of new features, with many promising ideas, like coroutines, remaining unimplemented despite being in the pipeline for years. The author suggests that the Rust community's consensus process has become unwieldy, leading to a graveyard of good ideas that never see the light of day. The author fantasizes about forking the Rust compiler to create a new version of the language, which they refer to as "seph." They propose several changes, starting with the introduction of function traits, which would allow developers to specify properties of functions, such as whether they can panic or if they are pure. This would enhance the language's ability to guarantee certain behaviors at compile time, addressing concerns like ensuring that specific blocks of code do not panic. Another significant proposal involves implementing compile-time capabilities to mitigate supply chain risks associated with third-party crates. The author suggests that functions interacting with sensitive operations, like file system access, should be marked with capabilities that require explicit whitelisting in a project's configuration. This would prevent potentially malicious code from being executed without the developer's knowledge. The author also critiques the complexity of Rust's Pin and borrow checker, arguing that the current implementation complicates the language unnecessarily. They propose a more intuitive system that would allow developers to express borrowing semantics directly in their code, making it easier to work with self-referential structures and async functions. Additionally, the author expresses admiration for Zig's compile-time capabilities, suggesting that Rust could benefit from a similar approach that allows developers to write compile-time code using the same syntax as regular Rust. They also list smaller improvements they would like to see, such as better ergonomics for raw pointers and enhancements to the language's collection types. In closing, the author acknowledges that many of their proposed changes would be incompatible with existing Rust, potentially requiring a new edition of the language. They express reluctance to engage with the RFC process, feeling that it often leads to frustration and unfulfilled ideas. Ultimately, they contemplate the possibility of forking Rust to implement their vision, though they recognize the challenges involved in such an endeavor.

On October 2, 2024, the Python community is set to release CPython v3.13.0, which introduces significant changes that could transform Python's performance. The two major updates are the introduction of a "free-threaded" version of CPython, allowing the Global Interpreter Lock (GIL) to be disabled, and the addition of an experimental Just-in-Time (JIT) compiler. The GIL has been a fundamental aspect of Python since its inception, designed to simplify memory management and make garbage collection more efficient. However, it restricts Python's ability to fully utilize multi-core processors, which has become increasingly important as hardware evolves. The GIL allows only one thread to execute Python bytecode at a time, which can lead to performance bottlenecks in CPU-bound applications. While Python can still leverage multiple cores through multiprocessing, this approach comes with its own complexities and overhead. The push to remove the GIL has gained momentum due to the growing prevalence of multi-core processors and the diminishing returns of single-core performance improvements. A proof of concept by Sam Gross in 2021 demonstrated the feasibility of a no-GIL implementation, leading to the proposal of PEP 703, which aims to make the GIL optional. This proposal has been accepted and will be rolled out in phases, with the first phase introducing free-threading as an experimental option. Benchmarks comparing Python 3.12 and 3.13 show that while enabling free-threading results in a performance degradation of about 20% for single-threaded tasks, it significantly enhances multi-threaded performance. The benchmarks also indicate that multi-threading with the GIL disabled performs comparably to multiprocessing, highlighting the potential benefits of the new free-threading mode. In addition to the GIL changes, Python 3.13 introduces an experimental JIT compiler, which compiles bytecode into machine code at runtime. This "copy-and-patch" JIT approach allows for optimizations based on how frequently certain code paths are executed, potentially leading to performance improvements over time. While the JIT is still in its early stages and may not yield immediate benefits, it sets the groundwork for future enhancements in Python's performance. To experiment with the new features, users can install the release candidate of Python 3.13 and enable free-threading or JIT support through specific commands. The community anticipates that as these features mature, they will significantly impact Python's performance, particularly for CPU-bound tasks. Overall, Python 3.13 represents a pivotal moment in the language's evolution, addressing long-standing limitations and paving the way for improved performance in a multi-core world. As developers begin to explore these new capabilities, the future of Python looks promising, with the potential for substantial advancements in efficiency and speed.

In the exploration of programming languages and their longevity, Timm Murray reflects on the enduring presence of COBOL, a language his grandfather once declared "dead" in a 1992 article for Technical Support magazine. The article, filled with the jargon of its time, highlights the perception of COBOL as a relic, yet it has proven to be remarkably resilient, outlasting many other programming languages that were once considered more modern. Murray humorously suggests that COBOL might be more accurately described as a "zombie" language—something that is technically dead but continues to exist in some form. He draws a parallel to Autocoder, an earlier programming language that has largely faded from use but still has remnants in the computing landscape. This notion challenges the finality of the term "dead" when applied to programming languages, as many continue to linger in legacy systems, supported by a dwindling number of programmers. The Y2K problem is identified as a significant factor in COBOL's continued relevance. Despite the hype surrounding the potential crisis, it prompted a resurgence in the demand for COBOL programmers, ensuring that the language remained in use longer than anticipated. Murray notes that programming languages with a substantial historical user base rarely disappear completely; instead, they fade into obscurity, often without new generations of programmers to carry them forward. On a personal note, Murray shares the recent passing of his grandfather, who died at the age of 91. His grandfather's death, attributed to pneumonia, follows the loss of his grandmother earlier that year. This personal reflection adds a layer of poignancy to the discussion of legacy, both in programming and in family history, as he recalls the dry wit of his grandfather and the pride he felt in mirroring his humor. Through this narrative, Murray encapsulates the complexities of programming languages, the impact of technological evolution, and the personal connections that intertwine with these themes.